package com.example.demo.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.port.fee.common.Result;
import com.port.fee.dto.FeeTypeDTO;
import com.port.fee.entity.FeeType;
import com.port.fee.service.FeeTypeService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 费用类型控制器
 */
@RestController
@RequestMapping("/fee-type")
@Tag(name = "费用类型", description = "费用类型相关接口")
public class FeeTypeController {

    private static final Logger LOGGER = LoggerFactory.getLogger(FeeTypeController.class);

    @Autowired
    private FeeTypeService feeTypeService;

    /**
     * 分页查询费用类型
     */
    @PostMapping("/list")
    @Operation(summary = "分页查询费用类型", description = "分页查询费用类型列表")
    public Result<Map<String, Object>> list(@RequestBody FeeTypeDTO feeTypeDTO) {
        try {
            // 转换对象
            FeeType feeType = new FeeType();
            BeanUtils.copyProperties(feeTypeDTO, feeType);

            // 默认值处理
            int pageNum = feeTypeDTO.getPageNum() == null ? 1 : feeTypeDTO.getPageNum();
            int pageSize = feeTypeDTO.getPageSize() == null ? 10 : feeTypeDTO.getPageSize();

            // 分页查询
            Page<FeeType> page = feeTypeService.listFeeTypes(feeType, pageNum, pageSize);

            // 封装返回结果
            Map<String, Object> data = new HashMap<>();
            data.put("records", page.getRecords());
            data.put("total", page.getTotal());
            data.put("pages", page.getPages());
            data.put("current", page.getCurrent());
            data.put("size", page.getSize());

            return Result.success(data);
        } catch (Exception e) {
            LOGGER.error("查询费用类型异常: ", e);
            return Result.failed("查询费用类型失败: " + e.getMessage());
        }
    }

    /**
     * 获取费用类型详情
     */
    @GetMapping("/{id}")
    @Operation(summary = "获取费用类型详情", description = "根据费用类型ID获取详情")
    public Result<FeeType> getInfo(@PathVariable("id") Long id) {
        FeeType feeType = feeTypeService.getFeeTypeById(id);
        if (feeType != null) {
            return Result.success(feeType);
        } else {
            return Result.failed("费用类型不存在");
        }
    }

    /**
     * 新增费用类型
     */
    @PostMapping
    @Operation(summary = "新增费用类型", description = "新增费用类型信息")
    public Result<Void> add(@RequestBody FeeTypeDTO feeTypeDTO) {
        try {
            // 验证必要参数
            if (feeTypeDTO.getFeeName() == null || feeTypeDTO.getFeeName().trim().isEmpty()) {
                return Result.failed("费用名称不能为空");
            }

            if (feeTypeDTO.getFeeCode() == null || feeTypeDTO.getFeeCode().trim().isEmpty()) {
                return Result.failed("费用编码不能为空");
            }

            if (feeTypeDTO.getUnitPrice() == null) {
                return Result.failed("单价不能为空");
            }

            // 检查费用编码是否已存在
            if (feeTypeService.checkFeeCodeExists(feeTypeDTO.getFeeCode(), null)) {
                return Result.failed("费用编码已存在");
            }

            FeeType feeType = new FeeType();
            BeanUtils.copyProperties(feeTypeDTO, feeType);

            // 设置默认值
            if (feeType.getFreeDays() == null) {
                feeType.setFreeDays(0);
            }

            if (feeType.getCurrency() == null) {
                feeType.setCurrency("CNY");
            }

            feeType.setCreateTime(new Date());
            feeType.setUpdateTime(new Date());

            if (feeTypeService.addFeeType(feeType)) {
                return Result.success(null, "新增成功");
            } else {
                return Result.failed("新增失败");
            }
        } catch (Exception e) {
            LOGGER.error("添加费用类型异常: ", e);
            return Result.failed("添加费用类型失败: " + e.getMessage());
        }
    }

    /**
     * 修改费用类型
     */
    @PutMapping
    @Operation(summary = "修改费用类型", description = "修改费用类型信息")
    public Result<Void> update(@RequestBody FeeTypeDTO feeTypeDTO) {
        try {
            if (feeTypeDTO.getFeeTypeId() == null) {
                return Result.failed("费用类型ID不能为空");
            }

            // 检查费用编码是否已存在
            if (feeTypeDTO.getFeeCode() != null && !feeTypeDTO.getFeeCode().isEmpty() &&
                    feeTypeService.checkFeeCodeExists(feeTypeDTO.getFeeCode(), feeTypeDTO.getFeeTypeId())) {
                return Result.failed("费用编码已存在");
            }

            FeeType feeType = new FeeType();
            BeanUtils.copyProperties(feeTypeDTO, feeType);

            feeType.setUpdateTime(new Date());

            if (feeTypeService.updateFeeType(feeType)) {
                return Result.success(null, "修改成功");
            } else {
                return Result.failed("修改失败");
            }
        } catch (Exception e) {
            LOGGER.error("修改费用类型异常: ", e);
            return Result.failed("修改费用类型失败: " + e.getMessage());
        }
    }

    /**
     * 删除费用类型
     */
    @DeleteMapping("/{id}")
    @Operation(summary = "删除费用类型", description = "根据ID删除费用类型")
    public Result<Void> delete(@PathVariable("id") Long id) {
        try {
            if (feeTypeService.deleteFeeType(id)) {
                return Result.success(null, "删除成功");
            } else {
                return Result.failed("删除失败");
            }
        } catch (Exception e) {
            LOGGER.error("删除费用类型异常: ", e);
            return Result.failed("删除费用类型失败: " + e.getMessage());
        }
    }

    /**
     * 检查费用编码是否已存在
     */
    @GetMapping("/check/{code}")
    @Operation(summary = "检查费用编码", description = "检查费用编码是否已存在")
    public Result<Boolean> checkFeeCode(@PathVariable("code") String code,
            @RequestParam(required = false) Long excludeId) {
        boolean exists = feeTypeService.checkFeeCodeExists(code, excludeId);
        return Result.success(exists);
    }

    /**
     * 获取所有费用类型
     */
    @GetMapping("/all")
    @Operation(summary = "获取所有费用类型", description = "获取所有费用类型列表")
    public Result<List<FeeType>> getAllFeeTypes() {
        try {
            List<FeeType> feeTypes = feeTypeService.list();
            return Result.success(feeTypes);
        } catch (Exception e) {
            LOGGER.error("获取所有费用类型异常: ", e);
            return Result.failed("获取所有费用类型失败: " + e.getMessage());
        }
    }
}